package Donnees;

import Metier.Objets.LotCuisson;
import java.sql.Connection;
import java.sql.PreparedStatement;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.sql.Statement;
import java.util.ArrayList;
import java.util.Calendar;
import java.util.List;

public class DaoLotCuisson {

    public DaoLotCuisson() { }

    /** Ajoute un LotCuisson en base
     * @param lot LotCuisson à ajouter
     * @return lotCuisson ajouté en base
     * @throws SQLException
     */
    public LotCuisson ajouter(LotCuisson lot) throws SQLException {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try{
            String query = "INSERT INTO LOT_CUISSON (nom, quantite, date, PRODUIT_id) VALUES (?, ?, ?, ?)";
            connection = ConnectionFactory.getConnection();
            preparedStatement = connection.prepareStatement(query, Statement.RETURN_GENERATED_KEYS);

            preparedStatement.setString(1, lot.getNom());
            preparedStatement.setInt(2, lot.getQuantite());
            preparedStatement.setTimestamp(3, lot.getDate());
            preparedStatement.setInt(4, lot.getProduit().getId());

            preparedStatement.executeUpdate();
            try (ResultSet generatedKeys = preparedStatement.getGeneratedKeys()) {
                if (generatedKeys.next()) {
                    lot.setId(generatedKeys.getInt(1));
                }
                else {
                    throw new SQLException("Creating LotCuisson failed, no ID obtained.");
                }
            }
        }
        finally{
            DbUtil.close(preparedStatement);
            DbUtil.close(connection);
        }
        return lot;
    }

    /** Recherche une liste de LotCuisson en fonction d'une clause where
     * @param whereClause Clause where
     * @return Liste des cuissons en fonction de la clause where
     * @throws SQLException
     */
    public List<LotCuisson> chercher(String whereClause) throws SQLException {
        Connection connection = null;
        Statement statement = null;
        ResultSet rs = null;
        List<LotCuisson> listeCuissons = new ArrayList<>();
        try {
            String query = "SELECT * FROM LOT_CUISSON " + whereClause;
            connection = ConnectionFactory.getConnection();
            statement = connection.createStatement();
            rs = statement.executeQuery(query);
            while (rs.next()) {
                listeCuissons.add(new LotCuisson(rs.getInt("id"),
                        rs.getString("nom"),
                        rs.getInt("quantite"),
                        rs.getTimestamp("date"),
                        new DaoProduit().chercher(rs.getInt("PRODUIT_id")))
                );
            }
        } finally {
            DbUtil.close(rs);
            DbUtil.close(statement);
            DbUtil.close(connection);
        }
        return listeCuissons;
    }

    /** Recherche toutes les cuissons présentes en base
     * @return Liste des cuissons
     * @throws SQLException
     */
    public List<LotCuisson> chercher() throws SQLException {
        return this.chercher("");
    }

    /** Recherche un LotCuisson en base en fonction d'un id
     * @param id id du LotCuisson à rechercher
     * @return LotCuisson trouvé, null sinon
     * @throws SQLException
     */
    public LotCuisson chercher(int id) throws SQLException {
        Connection connection = null;
        Statement statement = null;
        ResultSet rs = null;
        LotCuisson lotCuisson = null;
        try {
            String query = "SELECT * FROM LOT_CUISSON WHERE id="+id;
            connection = ConnectionFactory.getConnection();
            statement = connection.createStatement();
            rs = statement.executeQuery(query);
            if (rs.next()) {
                lotCuisson = new LotCuisson(rs.getInt("id"),
                        rs.getString("nom"),
                        rs.getInt("quantite"),
                        rs.getTimestamp("date"),
                        new DaoProduit().chercher(rs.getInt("PRODUIT_id")));
            }
        } finally {
            DbUtil.close(rs);
            DbUtil.close(statement);
            DbUtil.close(connection);
        }
        return lotCuisson;
    }

    /** Recherche une liste de LotCuisson en fonction de leur status
     * @param isArchive Status du LotCuisson
     * @return Liste de LotCuisson en fonction du status
     * @throws SQLException
     */
    public List<LotCuisson> chercher(boolean isArchive) throws SQLException {
        return this.chercher("WHERE estArchive="+isArchive);
    }

    /** Recherche une liste de LotCuisson en fonction d'une date
     * @param date Date de cuisson des LotCuisson
     * @return Liste de LotCuisson en fonction d'une date
     * @throws SQLException
     */
    public List<LotCuisson> chercher(java.util.Date date) throws SQLException {
        java.sql.Date borneInf = new java.sql.Date(date.getTime());
        java.sql.Date borneSup;
        Calendar c = Calendar.getInstance();
        c.setTime(date);
        c.add(Calendar.DAY_OF_MONTH, 1);
        borneSup = new java.sql.Date(c.getTime().getTime());
        String whereClause = "WHERE date >= TIMESTAMP('" + borneInf + "', 'YYYY-MM-DD') "+
                "AND date < TIMESTAMP('" + borneSup + "', 'YYYY-MM-DD')";
        return chercher(whereClause);
    }

    /** Modifie un LotCuisson en base
     * @param lotCuisson LotCuisson modifié
     * @return LotCuisson modifié
     * @throws SQLException
     */
    public LotCuisson modifier(LotCuisson lotCuisson) throws SQLException {
        Connection connection = null;
        PreparedStatement preparedStatement = null;
        try{
            String query = "UPDATE LOT_CUISSON SET nom = ?, quantite = ?, date = ?, estArchive = ?, PRODUIT_id = ?"
                    + " where id = ?";
            connection = ConnectionFactory.getConnection();

            preparedStatement = connection.prepareStatement(query);
            preparedStatement.setString(1, lotCuisson.getNom());
            preparedStatement.setInt(2, lotCuisson.getQuantite());
            preparedStatement.setTimestamp(3, lotCuisson.getDate());
            preparedStatement.setBoolean(4, lotCuisson.isEstArchive());
            preparedStatement.setInt(5, lotCuisson.getProduit().getId());
            preparedStatement.setInt(6, lotCuisson.getId());

            preparedStatement.executeUpdate();
        }
        finally{
            DbUtil.close(preparedStatement);
            DbUtil.close(connection);
        }
        return lotCuisson;
    }

    /** Supprime un LotCuisson en base
     * @param lotCuisson LotCuisson à supprimer
     * @throws SQLException
     */
    public void supprimer(LotCuisson lotCuisson) throws SQLException {
        Connection connection = null;
        Statement statement = null;
        try {
            String query = "DELETE FROM LOT_CUISSON where id=" + lotCuisson.getId();
            connection = ConnectionFactory.getConnection();
            statement = connection.createStatement();
            statement.execute(query);
        } finally {
            DbUtil.close(statement);
            DbUtil.close(connection);
        }
    }

    /** Supprime un LotCuisson en base en fonction d'un id
     * @param id id du LotCuisson à supprimer
     * @throws SQLException
     */
    public void supprimer(int id) throws SQLException {
        Connection connection = null;
        Statement statement = null;
        try {
            String query = "DELETE FROM LOT_CUISSON where id=" + id;
            connection = ConnectionFactory.getConnection();
            statement = connection.createStatement();
            statement.execute(query);
        } finally {
            DbUtil.close(statement);
            DbUtil.close(connection);
        }
    }
}
